package service;

import bean.*;
import dao.UserDaoImpl;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 李夏
 * @version 1.0
 */
public class UserServiceImpl implements UserService {




    public static String getQuerySqlStu2(String reason, Integer newRoom, Integer oldRoom,Integer newBed, Integer oldBuild,  Integer buildId, String stuName) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (reason != null && !reason.isEmpty()) {
            conditions.add("reason");
        }
        if (oldRoom !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("old_room");
        }
        if (newRoom !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("new_room");
        }



        if (newBed  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("new_bed");
        }
        if (oldBuild != null && oldBuild!= 0) {
            conditions.add("old_build");
        }
        if (buildId != 0) {
            conditions.add("build_id");
        }
        if (stuName != null && !stuName.isEmpty()) {
            conditions.add("stu_name");
        }




        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }

    @Override
    public Student findByPasswordAndId(String stuPassword, int  stuId) {
        return new UserDaoImpl().findByPasswordAndId(stuPassword,stuId);
    }

    @Override
 public Student isSignSuccess(Student student) {
        return new UserDaoImpl().isSignSuccess(student);
    }

    @Override
    public Teacher teaFindByPasswordAndId(String teaPassword, int teaId) {
        return new UserDaoImpl().teaFindByPasswordAndId(teaPassword,teaId);

    }

    @Override
    public Teacher teaIsSignSuccess(String teaPassword, int teaId, String teaName, int teaTel) {
        return new UserDaoImpl().teaIsSignSuccess(teaPassword,teaId,teaName,teaTel);

    }

    @Override
    public Hou houFindByPasswordAndId(String houPassword, int houId) {
        return new UserDaoImpl().houFindByPasswordAndId(houPassword,houId);

    }

    @Override
    public Hou houIsSignSuccess(Hou hou) {
        return new UserDaoImpl().houIsSignSuccess(hou);

    }

    @Override
    public Manager manFindByPasswordAndId(String manPassword, int manId) {
        return new UserDaoImpl().manFindByPasswordAndId(manPassword,manId);

    }

    @Override
    public Manager manIsSignSuccess(String manPassword, int manId, String manName, int manTel) {
        return new UserDaoImpl().manIsSignSuccess(manPassword,manId,manName,manTel);

    }
    public static String getQuerySql(String stuName, String profession, Integer age, Integer sex, String phone, String email, String college, String password,Integer electric) {

        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (stuName != null && !stuName.isEmpty()) {
            conditions.add("stu_name = ?");
        }
        if (profession != null && !profession.isEmpty()) {
            conditions.add("profession = ?");
        }
        if (age != null &&age !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("age = ?");
        }
        if (sex != null &&sex  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("sex = ?");
        }
        if (phone != null && !phone.isEmpty()) {
            conditions.add("phone = ?");
        }
        if (email != null && !email.isEmpty()) {
            conditions.add("email = ?");
        }



        if (college != null && !college.isEmpty()) {
            conditions.add("college = ?");
        }
        if (password != null && !password.isEmpty()) {
            conditions.add("password = ?");
        }
        if (electric != null &&electric  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("electric = ?");
        }
        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }
    public static String getQuerySqlHou(String houName, int age, int sex, String phone, String email, String password) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (houName != null && !houName.isEmpty()) {
            conditions.add("hou_name = ?");
        }

        if (age !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("age = ?");
        }
        if (sex  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("sex = ?");
        }
        if (phone != null && !phone.isEmpty()) {
            conditions.add("phone = ?");
        }
        if (email != null && !email.isEmpty()) {
            conditions.add("email = ?");
        }

        if (password != null && !password.isEmpty()) {
            conditions.add("password = ?");
        }

        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }

    public static String getQuerySqlMan(String manName, int age, int sex, String phone, String email, String password) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (manName != null && !manName.isEmpty()) {
            conditions.add("man_name = ?");
        }

        if (age !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("age = ?");
        }
        if (sex  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("sex = ?");
        }
        if (phone != null && !phone.isEmpty()) {
            conditions.add("phone = ?");
        }
        if (email != null && !email.isEmpty()) {
            conditions.add("email = ?");
        }

        if (password != null && !password.isEmpty()) {
            conditions.add("password = ?");
        }

        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }
    public static String getQuerySqlStu(String reason, Integer newRoom, Integer newBed, String phone, Integer buildId) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (reason != null && !reason.isEmpty()) {
            conditions.add("reason = ?");
        }

        if (newRoom !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("new_room = ?");
        }
        if (newBed  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("new_bed = ?");
        }
        if (phone != null && !phone.isEmpty()) {
            conditions.add("phone = ?");
        }
        if (buildId != 0) {
            conditions.add("build_id = ?");
        }



        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }
    public static String getQuerySqlHouIdName(Integer houId, String houName) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (houName != null && !houName.isEmpty()) {
            conditions.add("hou_name = ?");
        }

        if (houId !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("hou_id = ?");
        }

        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to select");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();

    }
    public static String getQuerySqlHygHou(Integer hygId, String hygDes, Integer dorNumber, Integer checkSore,Integer doId,String checkPerson) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (hygDes != null && !hygDes.isEmpty()) {
            conditions.add("hyg_des = ?");
        }

        if (dorNumber != null &&dorNumber !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("dor_number = ?");
        }
        if (checkSore != null &&checkSore  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("check_sore = ?");
        }
        if (doId!= null &&doId  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("do_id = ?");
        }
        if (checkPerson != null && !checkPerson.isEmpty()) { // 假设0是一个默认值，表示不更新
            conditions.add("check_person = ?");
        }



        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }
    public static String getQuerySqlPubHou(String publicName, Integer buildId, Integer publicCount, Integer publicAlready, String stuName,
                                           Integer stuId, Integer publicTime, Integer deleteFlag) {
        StringBuilder sb = new StringBuilder();

        // 使用逗号分隔的条件列表，用于构建SQL的SET部分
        List<String> conditions = new ArrayList<>();

        // 检查每个参数，如果它们不是null或满足其他条件（例如，对于整数类型，不是某个默认值），则添加到条件列表中
        if (publicName != null && !publicName.isEmpty()) {
            conditions.add("public_name = ?");
        }
        if (buildId!= null && buildId !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("build_id = ?");
        }

        if (publicCount != null &&publicCount  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("public_count = ?");
        }
        if (publicAlready != null &&publicAlready  != 0) { // 假设0是一个默认值，表示不更新
            conditions.add("public_already = ?");
        }
        if (stuName != null && !stuName.isEmpty()) {
            conditions.add("stu_name = ?");
        }

        if (stuId!= null &&stuId !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("stu_id = ?");
        }
        if (publicTime!= null  &&publicTime !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("public_time = ?");
        }
        if (deleteFlag != null &&deleteFlag !=0) { // 假设0是一个默认值，表示不更新
            conditions.add("delete_flag = ?");
        }




        // 如果条件列表为空，则不需要更新任何字段，但通常我们会抛出一个异常或返回一个错误，因为调用此方法意味着打算更新某些字段
        if (conditions.isEmpty()) {
            throw new IllegalArgumentException("No fields to update");
        }

        // 将条件列表转换为以逗号分隔的字符串，用于SQL的SET部分
        for (int i = 0; i < conditions.size(); i++) {
            sb.append(conditions.get(i));
            if (i < conditions.size() - 1) {
                sb.append(", ");
            }
        }

        return sb.toString();
    }

}
